/**
 * 工单管理相关API
 * 封装工单列表、详情、处理、评价等功能的接口
 */

import request from './request.js';

// API路径配置
const API_ROUTES = {
  TICKET: {
    // 工单基础操作
    LIST: '/api/tickets/list',              // 获取工单列表
    DETAIL: '/api/tickets/detail',          // 获取工单详情
    CREATE: '/api/tickets/create',          // 创建工单
    UPDATE: '/api/tickets/update',          // 更新工单
    CLOSE: '/api/tickets/close',            // 关闭工单
    
    // 工单处理
    ASSIGN: '/api/tickets/assign',          // 分配工单
    GRAB: '/api/tickets/grab',              // 抢单
    PROCESS: '/api/tickets/process',        // 处理工单
    TRANSFER: '/api/tickets/transfer',      // 转单
    
    // 工单评价
    RATE: '/api/tickets/rate',              // 评价工单
    FEEDBACK: '/api/tickets/feedback',      // 工单反馈
    
    // 工单统计
    STATS: '/api/tickets/stats',            // 工单统计
    PERFORMANCE: '/api/tickets/performance', // 绩效统计
    
    // 工单流程
    FLOWS: '/api/tickets/flows',            // 获取工单流程
    FLOW_CREATE: '/api/tickets/flow/create', // 创建工单流程
    FLOW_UPDATE: '/api/tickets/flow/update', // 更新工单流程
    FLOW_DELETE: '/api/tickets/flow/delete', // 删除工单流程
  }
};

/**
 * 工单API封装
 */
export default {
  /**
   * 获取工单列表
   * @param {Object} params - 查询参数 {unitId, status, priority, type, assigneeId, creatorId, page, limit}
   * @returns {Promise} 工单列表数据
   */
  getTicketList(params = {}) {
    return request({
      url: API_ROUTES.TICKET.LIST,
      method: 'GET',
      data: params
    });
  },
  
  /**
   * 获取工单详情
   * @param {String} ticketId - 工单ID
   * @returns {Promise} 工单详情数据
   */
  getTicketDetail(ticketId) {
    return request({
      url: API_ROUTES.TICKET.DETAIL,
      method: 'GET',
      data: { ticketId }
    });
  },
  
  /**
   * 创建工单
   * @param {Object} ticketData - 工单数据
   * @returns {Promise} 创建结果
   */
  createTicket(ticketData) {
    return request({
      url: API_ROUTES.TICKET.CREATE,
      method: 'POST',
      data: ticketData
    });
  },
  
  /**
   * 更新工单
   * @param {Object} ticketData - 工单数据，包含ticketId
   * @returns {Promise} 更新结果
   */
  updateTicket(ticketData) {
    return request({
      url: API_ROUTES.TICKET.UPDATE,
      method: 'PUT',
      data: ticketData
    });
  },
  
  /**
   * 关闭工单
   * @param {String} ticketId - 工单ID
   * @param {Object} closeData - 关闭数据，包含原因等
   * @returns {Promise} 关闭结果
   */
  closeTicket(ticketId, closeData = {}) {
    return request({
      url: API_ROUTES.TICKET.CLOSE,
      method: 'POST',
      data: {
        ticketId,
        ...closeData
      }
    });
  },
  
  /**
   * 分配工单
   * @param {String} ticketId - 工单ID
   * @param {String} assigneeId - 分配人ID
   * @param {Object} assignData - 分配数据，包含备注等
   * @returns {Promise} 分配结果
   */
  assignTicket(ticketId, assigneeId, assignData = {}) {
    return request({
      url: API_ROUTES.TICKET.ASSIGN,
      method: 'POST',
      data: {
        ticketId,
        assigneeId,
        ...assignData
      }
    });
  },
  
  /**
   * 抢单
   * @param {String} ticketId - 工单ID
   * @returns {Promise} 抢单结果
   */
  grabTicket(ticketId) {
    return request({
      url: API_ROUTES.TICKET.GRAB,
      method: 'POST',
      data: { ticketId }
    });
  },
  
  /**
   * 处理工单
   * @param {String} ticketId - 工单ID
   * @param {Object} processData - 处理数据
   * @returns {Promise} 处理结果
   */
  processTicket(ticketId, processData) {
    return request({
      url: API_ROUTES.TICKET.PROCESS,
      method: 'POST',
      data: {
        ticketId,
        ...processData
      }
    });
  },
  
  /**
   * 转单
   * @param {String} ticketId - 工单ID
   * @param {String} targetId - 目标人ID
   * @param {Object} transferData - 转单数据，包含原因等
   * @returns {Promise} 转单结果
   */
  transferTicket(ticketId, targetId, transferData = {}) {
    return request({
      url: API_ROUTES.TICKET.TRANSFER,
      method: 'POST',
      data: {
        ticketId,
        targetId,
        ...transferData
      }
    });
  },
  
  /**
   * 评价工单
   * @param {String} ticketId - 工单ID
   * @param {Object} rateData - 评价数据
   * @returns {Promise} 评价结果
   */
  rateTicket(ticketId, rateData) {
    return request({
      url: API_ROUTES.TICKET.RATE,
      method: 'POST',
      data: {
        ticketId,
        ...rateData
      }
    });
  },
  
  /**
   * 工单反馈
   * @param {String} ticketId - 工单ID
   * @param {Object} feedbackData - 反馈数据
   * @returns {Promise} 反馈结果
   */
  feedbackTicket(ticketId, feedbackData) {
    return request({
      url: API_ROUTES.TICKET.FEEDBACK,
      method: 'POST',
      data: {
        ticketId,
        ...feedbackData
      }
    });
  },
  
  /**
   * 获取工单统计
   * @param {Object} params - 查询参数 {unitId, timeRange, type}
   * @returns {Promise} 统计数据
   */
  getTicketStats(params = {}) {
    return request({
      url: API_ROUTES.TICKET.STATS,
      method: 'GET',
      data: params
    });
  },
  
  /**
   * 获取绩效统计
   * @param {Object} params - 查询参数 {unitId, userId, timeRange}
   * @returns {Promise} 绩效数据
   */
  getPerformanceStats(params = {}) {
    return request({
      url: API_ROUTES.TICKET.PERFORMANCE,
      method: 'GET',
      data: params
    });
  },
  
  /**
   * 获取工单流程
   * @param {Object} params - 查询参数 {unitId}
   * @returns {Promise} 流程数据
   */
  getTicketFlows(params = {}) {
    return request({
      url: API_ROUTES.TICKET.FLOWS,
      method: 'GET',
      data: params
    });
  },
  
  /**
   * 创建工单流程
   * @param {Object} flowData - 流程数据
   * @returns {Promise} 创建结果
   */
  createTicketFlow(flowData) {
    return request({
      url: API_ROUTES.TICKET.FLOW_CREATE,
      method: 'POST',
      data: flowData
    });
  },
  
  /**
   * 更新工单流程
   * @param {Object} flowData - 流程数据，包含flowId
   * @returns {Promise} 更新结果
   */
  updateTicketFlow(flowData) {
    return request({
      url: API_ROUTES.TICKET.FLOW_UPDATE,
      method: 'PUT',
      data: flowData
    });
  },
  
  /**
   * 删除工单流程
   * @param {String} flowId - 流程ID
   * @returns {Promise} 删除结果
   */
  deleteTicketFlow(flowId) {
    return request({
      url: API_ROUTES.TICKET.FLOW_DELETE,
      method: 'DELETE',
      data: { flowId }
    });
  }
}; 